#
# Jamrules file to build CUnit - Root Directory
# (see http://www.freetype.org/jam/index.html)
#
# Copyright (C) 2004-2006  Jerry St.Clair
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Library General Public
# License as published by the Free Software Foundation; either
# version 2 of the License, or (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# Library General Public License for more details.
#
# You should have received a copy of the GNU Library General Public
# License along with this library; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
#---------------------------------------------------------------------------

# On Linux, basic build options are set by configure.  
# See else clause below for other platforms.
if $(OS) = LINUX || $(UNIX)
{
  SLASH = / ;
  VERSION = @VERSION@ ;
  RELEASE = @RELEASE@ ;
  VERSION_MAJOR = @VERSION_MAJOR@ ;
  VERSION_MINOR = @VERSION_MINOR@ ;
  
  # root of install path
  prefix = @prefix@ ;

  # choice of interfaces to build into library
  if @BUILD_AUTOMATED@ = TRUE
    { BUILD_AUTOMATED = 1 ; }
  if @BUILD_BASIC@ = TRUE
    { BUILD_BASIC = 1 ; }
  if @BUILD_CONSOLE@ = TRUE
    { BUILD_CONSOLE = 1 ; }
  if @BUILD_CURSES@ != FALSE
  { 
    BUILD_CURSES = 1 ; 
    SYS_LIBS = -l@CURSES_LIB@ ;
  }
#  BUILD_WINDOWS = 1 ;
  
  # choice of whether to build examples
  if @BUILD_EXAMPLES@ = TRUE
    { BUILD_EXAMPLES = 1 ; }
  
  # choice of whether to build test program
  if @BUILD_TEST@ = TRUE
    { BUILD_TEST = 1 ; }
  
  # choice of whether to build shared library
  if @ENABLE_SHARED@ = TRUE
    { BUILD_SHARED_LIB = 1 ; }

  # choice of whether to build static library
  if @ENABLE_STATIC@ = TRUE
    { BUILD_STATIC_LIB = 1 ; }

  # debug compilation mode
  if @ENABLE_DEBUG@ = FALSE
    { NODEBUG = 1 ; }

  # Use memory tracing
  if @ENABLE_MEMTRACE@ = TRUE
    { USE_MEMTRACE = -DMEMTRACE ; }

  # Recognize deprecated version 1.1 function names and build V1.1 examples
  if @ENABLE_DEPRECATED@ = TRUE
    { USE_DEPRECATED_NAMES = -DUSE_DEPRECATED_CUNIT_NAMES ; }
}

# On other platforms, comment out the option to disable it
else
{
  SLASH = \\ ;
  
  # Version number set manually so may be out-of-date
  VERSION = 2.1 ;
  RELEASE = 0 ;
  VERSION_MAJOR = 2 ;
  VERSION_MINOR = 1 ;

  # Set the root of install path
  prefix = c:\\dev\\CUnit_install ;

  # Comment to not include interface in library
  BUILD_AUTOMATED = 1 ; 
  BUILD_BASIC = 1 ; 
  BUILD_CONSOLE = 1 ; 
#  BUILD_CURSES = 1 ; 
  BUILD_WINDOWS = 1 ;
    
  # Comment to not build examples
  BUILD_EXAMPLES = 1 ; 
  
  # Comment to not build test program
  BUILD_TEST = 1 ; 
  
  # Comment to not build CUnit shared library
  BUILD_SHARED_LIB = 1 ; 

  # Comment to not build CUnit static library
  BUILD_STATIC_LIB = 1 ; 
  
  # Comment to compile with debugging & assertions enabled
  NODEBUG = 1 ;

  # Uncomment to perform memory tracing
  #USE_MEMTRACE = -DMEMTRACE ;

  # Uncomment to recognize deprecated version 1.1 function names
  # and build V1.1 examples
  #USE_DEPRECATED_NAMES = -DUSE_DEPRECATED_CUNIT_NAMES ;
}

#---------------------------------------------------------------------------
# Options from here on should not require routine tweaking

PACKAGE = CUnit ;

# Install locations - comment out to not install that class of file
INSTALL_BIN_DIR   = $(prefix)$(SLASH)bin ;
INSTALL_LIB_DIR   = $(prefix)$(SLASH)lib ;
INSTALL_INC_DIR   = $(prefix)$(SLASH)include$(SLASH)CUnit ;
INSTALL_DOC_DIR   = $(prefix)$(SLASH)doc$(SLASH)CUnit ;
INSTALL_MAN_DIR   = $(prefix)$(SLASH)man ;
INSTALL_SHARE_DIR = $(prefix)$(SLASH)share$(SLASH)CUnit ;
#INSTALL_EXAM_DIR  = $(prefix)$(SLASH)share$(SLASH)CUnit$(SLASH)Examples ;
#INSTALL_TEST_DIR  = $(prefix)$(SLASH)share$(SLASH)CUnit$(SLASH)Test ;

# Build directory - - will be qualified for compiler & build type
BUILD_DIR_ROOT = $(TOP) ;

EXAMPLES_DIR   = $(TOP)$(SLASH)Examples ;

CUNIT_HDR_DIR  = $(TOP)$(SLASH)CUnit$(SLASH)Headers ;
CUNIT_LIB_NAME = libcunit ;

# Comment for normal jam deletion of object files after building targets
KEEPOBJS = true ;

if $(NODEBUG)
{
  CCFLAGS += -DNDEBUG ;
  BUILD_SUBDIR = $(SLASH)Release ;
}
else
{
  BUILD_SUBDIR = $(SLASH)Debug ;
}

if $(NT)
{
  # variables not set properly for Windows/Win9x in Jambase 2.3
  RM = del ;
  MV = move /Y ;

  SUFSHR = .dll ;

  # Windows-specific defines
  CCFLAGS = -DWIN32 -D_LIB -D_MBCS -D_DELAYTEST ;
  CUNIT_WIN_DIR = $(TOP)$(SLASH)CUnit$(SLASH)Sources$(SLASH)Win ;

  if $(BCCROOT) || ( $(TOOLSET) = BORLANDC )
  {
    CCFLAGS   += -q -d -g0 -j0 ;
    CCWARN    = -w -w-8004 ;
    if $(NODEBUG)
    {
      CCDEBUG = -v- -O2 ;
    }
    else
    {
      CCDEBUG = -v -y -Od ;
    }
    BUILD_SUBDIR = $(BUILD_SUBDIR)$(SLASH)bcc ;
  }

  else if $(MSVCNT) || ( $(TOOLSET) = VISUALC )
  {
    CCFLAGS   += /Ze ;
    CCWARN    = /W4 ;
    if $(NODEBUG)
    {
      CCDEBUG = /O2 ;
    }
    else
    {
      CCDEBUG = /Zi /Od ;
    }
    # Libraries are in different paths depending on VC version
    LINKFLAGS += /LIBPATH:$(VISUALC)\\lib /LIBPATH:$(VISUALC)\\PlatformSDK\\lib\\ ;
    LINKLIBS = advapi32.lib
               libc.lib
               oldnames.lib
               gdi32.lib
               user32.lib
               kernel32.lib ;
    BUILD_SUBDIR = $(BUILD_SUBDIR)$(SLASH)msvc ;
  }


  else if $(MINGW) || ( $(TOOLSET) = MINGW )
  {
    # uncomment to select desired warning level and ansi-strictness
    CCWARN += -Wall ;
    CCWARN += -W ;
    CCWARN += -pedantic ;
    CCWARN += -Wshadow ;
    CCWARN += -ansi ;

    if $(NODEBUG)
    {
      CCDEBUG = -O3 ;
    }
    else
    {
      CCDEBUG = -g -O0 ;
    }
    BUILD_SUBDIR = $(BUILD_SUBDIR)$(SLASH)mingw ;
  }

  else if $(WATCOM) || ( $(TOOLSET) = WATCOM )
  {
    CCFLAGS += /fr ;
    CCWARN    = /wx ;
    if $(NODEBUG)
    {
      CCDEBUG = /ox ;
    }
    else
    {
      CCDEBUG = /od /d2 ;
    }
    BUILD_SUBDIR = $(BUILD_SUBDIR)$(SLASH)watcom ;
  }
}

else if $(OS) = LINUX
{
  SUFSHR = .so ;

  # uncomment to select desired warning level and ansi-strictness
  CCWARN += -Wall ;
  CCWARN += -W ;
  CCWARN += -pedantic ;
  CCWARN += -Wshadow ;
  CCWARN += -ansi ;

  if $(NODEBUG)
  {
    CCDEBUG = -O3 ;
  }
  else
  {
    CCDEBUG = -g -O0 ;
  }
  BUILD_SUBDIR = $(BUILD_SUBDIR)$(SLASH)linux ;
}

CCFLAGS  += $(USE_MEMTRACE) $(CCWARN) $(CCDEBUG) ;
C++FLAGS += $(CCFLAGS) ;
BUILD_DIR = $(BUILD_DIR_ROOT)$(BUILD_SUBDIR) ;

#----------------------------------------------------------------------
# CUnit-specific rules & actions
#----------------------------------------------------------------------
# If anyone can figure out a better way, good for you
# (and let me (jds) know)!  Here's the problem...
# The built-in Jam install rules all convert the grist of
# the source file to (:G=installed).  As a result, they
# seem unable to handle files having the same name in
# different directories.  If we want to install such files
# as the Jamfile's or Makefile.am's or README's, the built-ins
# can't handle it (in my hands, anyway).  As a workaround,
# we define a new rule which does not monkey with the grist
# in this way.  Duplicate file names will need to explicitly
# use grist so Jam knows the difference, but the standard
# <$(SOURCE_GRIST)> works in most cases.
#
rule DoInstallCUnitFile
{
    local i t ;

    t = $(>:D=$(<)) ;

    DEPENDS install : $(t) ;
    DEPENDS $(t) : $(>) ;
    SEARCH on $(>) = $(SEARCH_SOURCE) ;
    MakeLocate $(t) : $(<) ;

    # Arrange for jam uninstall

    Clean uninstall : $(t) ;

    for i in $(>)
    {
        Install $(i:D=$(<)) : $(i) ;
        Chmod $(i:D=$(<)) ;
    }

    if $(UNIX)
    {
        if $(OWNER) { Chown $(t) ; OWNER on $(t) = $(OWNER) ; }
        if $(GROUP) { Chgrp $(t) ; GROUP on $(t) = $(GROUP) ; }
    }
}

rule InstallCUnitBin
{
    DoInstallCUnitFile $(<) : $(>) ;
    MODE on $(>:D=$(<)) = $(EXEMODE) ;
}

rule InstallCUnitFile
{
    DoInstallCUnitFile $(<) : $(>) ;
    MODE on $(>:D=$(<)) = $(FILEMODE) ;
}

#----------------------------------------------------------
# MakeImportLibrary
#
# This is a dummy rule.  Import libraries are built in
# the dll linking directive.  However, jam doesn't know
# that, so we provide a rule which does nothing more
# than define a dependency.
#
# Parameters:
#
# 1 - name of the dll
# 2 - name of the import library
#----------------------------------------------------------
rule MakeImportLibrary
{
  DEPENDS $(>) : $(<) ;
  LOCATE on $(>) = $(BUILD_DIR) ;
}

